package br.ufrn.sipac.patrimonio.coletor.controller;

import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;

import android.content.Context;
import br.ufrn.sipac.patrimonio.auxiliares.ConstantesOperacoes;
import br.ufrn.sipac.patrimonio.auxiliares.StatusLevantamento;
import br.ufrn.sipac.patrimonio.coletor.dominio.Bem;
import br.ufrn.sipac.patrimonio.coletor.dominio.FinalidadeLevantamento;
import br.ufrn.sipac.patrimonio.coletor.dominio.Levantamento;
import br.ufrn.sipac.patrimonio.coletor.dominio.Localidade;
import br.ufrn.sipac.patrimonio.coletor.dominio.Persistencia;
import br.ufrn.sipac.patrimonio.coletor.dominio.Unidade;
import br.ufrn.sipac.patrimonio.coletor.dominio.UsuarioColetor;
import br.ufrn.sipac.patrimonio.coletor.exception.DatabaseException;
import br.ufrn.sipac.patrimonio.coletor.exception.NegocioException;
import br.ufrn.sipac.patrimonio.coletor.exception.TransmissaoException;
import br.ufrn.sipac.patrimonio.coletor.helper.DatabaseHelper;
import br.ufrn.sipac.patrimonio.coletor.transmissao.GenericSOAP;

/**
 * Essa classe funciona como uma fachada para encaminhar as requisições
 * propragadas da camada de visão.
 * 
 * @author Giuliana Silva Bezerra
 * 
 */
public class MainController {
	private static int countBensNaoCadastrados;
	private static Collection<Persistencia> bensNaoCadastrados = new ArrayList<Persistencia>();
	private static int countBensNaoInventariados;
	private static Collection<Persistencia> bensNaoInventariados = new ArrayList<Persistencia>();
	private static int countBensBaixados;
	private static Collection<Persistencia> bensBaixados = new ArrayList<Persistencia>();
	private static int countBensInventariados;
	private static Collection<Persistencia> bensInventariados = new ArrayList<Persistencia>();
	private static String tombo;
	private static ConstantesOperacoes tipoOperacao;
	private static ConstantesOperacoes tipoAutenticacao;
	private static String stacktrace;

	public static Bem findByTombamento(Integer numTombamento, Context context)
			throws TransmissaoException {
		GenericSOAP gen = new GenericSOAP();
		Bem bem = gen.findByNumCod(numTombamento, context);
		return bem;
	}

	public static Collection<FinalidadeLevantamento> findFinalidadesLevantamento(
			Context context) throws DatabaseException, TransmissaoException {
		Collection<FinalidadeLevantamento> finalidades = new ArrayList<FinalidadeLevantamento>();
		GenericSOAP gen = new GenericSOAP();
		Collection<Object> objs = gen.findFinalidadesLevantamentoSOAP(context);

		for (Object ob : objs) {
			FinalidadeLevantamento finalidade = (FinalidadeLevantamento) ob;
			finalidades.add(finalidade);

			try {
				// Salva ou atualiza os dados localmente
				FinalidadeLevantamento finalidadeBD = (FinalidadeLevantamento) DatabaseHelper
						.getHelper(context).getFinalidadeDAO()
						.queryForId(finalidade.getId());
				if (finalidadeBD == null)
					DatabaseHelper.getHelper(context).getFinalidadeDAO()
							.create(finalidade);
				else
					DatabaseHelper.getHelper(context).getFinalidadeDAO()
							.update(finalidade);
			} catch (SQLException e) {
				throw new DatabaseException(e.getMessage(), context);
			}
		}

		return finalidades;
	}

	public static int getCountBensNaoCadastrados() {
		return countBensNaoCadastrados;
	}

	public static void setCountBensNaoCadastrados(int bensNaoCadastrados) {
		MainController.countBensNaoCadastrados = bensNaoCadastrados;
	}

	public static Collection<Persistencia> getBensNaoCadastrados() {
		return bensNaoCadastrados;
	}

	public static void setBensNaoCadastrados(
			Collection<Persistencia> bensNaoCadastrados) {
		MainController.bensNaoCadastrados = bensNaoCadastrados;
	}

	public static Collection<Persistencia> getBensNaoInventariados() {
		return bensNaoInventariados;
	}

	public static void setBensNaoInventariados(
			Collection<Persistencia> bensNaoInventariados) {
		MainController.bensNaoInventariados = bensNaoInventariados;
	}

	public static int getCountBensNaoInventariados() {
		return countBensNaoInventariados;
	}

	public static void setCountBensNaoInventariados(
			int countBensNaoInventariados) {
		MainController.countBensNaoInventariados = countBensNaoInventariados;
	}

	public static int getCountBensBaixados() {
		return countBensBaixados;
	}

	public static void setCountBensBaixados(int countBensBaixados) {
		MainController.countBensBaixados = countBensBaixados;
	}

	public static Collection<Persistencia> getBensBaixados() {
		return bensBaixados;
	}

	public static void setBensBaixados(Collection<Persistencia> bensBaixados) {
		MainController.bensBaixados = bensBaixados;
	}

	public static int getCountBensInventariados() {
		return countBensInventariados;
	}

	public static void setCountBensInventariados(int countBensInventariados) {
		MainController.countBensInventariados = countBensInventariados;
	}

	public static Collection<Persistencia> getBensInventariados() {
		return bensInventariados;
	}

	public static void setBensInventariados(
			Collection<Persistencia> bensInventariados) {
		MainController.bensInventariados = bensInventariados;
	}

	public static void setTombo(String text) {
		tombo = text;
	}

	public static String getTombo() {
		return tombo;
	}

	public static ConstantesOperacoes getTipoOperacao() {
		return tipoOperacao;
	}

	public static void setTipoOperacao(ConstantesOperacoes tipoOperacao) {
		MainController.tipoOperacao = tipoOperacao;
	}
	
	public static String getStacktrace() {
		return stacktrace;
	}

	public static void setStacktrace(String stacktrace) {
		MainController.stacktrace = stacktrace;
	}

	public static UsuarioColetor capturarUsuario(String login, Context context)
			throws DatabaseException, TransmissaoException {
		GenericSOAP gen = new GenericSOAP();
		UsuarioColetor usuario = gen.capturarUsuario(login, context);

		try {
			// Salva ou atualiza os dados localmente
			Persistencia usuarioBD = DatabaseHelper.getHelper(context)
					.getUsuarioDAO().queryForId(usuario.getId());
			if (usuarioBD == null)
				DatabaseHelper.getHelper(context).getUsuarioDAO()
						.create(usuario);
			else
				DatabaseHelper.getHelper(context).getUsuarioDAO()
						.update(usuario);
		} catch (SQLException e) {
			throw new DatabaseException(e.getMessage(), context);
		}
		return usuario;
	}

	public static Collection<Localidade> findLocaisByUnidade(Context context,
			int idUnidade, long codigo) throws NegocioException,
			DatabaseException, TransmissaoException {
		GenericSOAP gen = new GenericSOAP();
		Collection<Localidade> localidades = new ArrayList<Localidade>();
		try {
			// Carrega dados remotos e persiste localmente.
			if (tipoOperacao == ConstantesOperacoes.MODO_ONLINE) {
				Collection<Object> objs = gen.findLocaisByUnidade(idUnidade,
						codigo, context);
				for (Object object : objs) {
					Localidade local = (Localidade) object;
					localidades.add(local);

					// Salva ou atualiza os dados localmente
					Persistencia localidadeBD = DatabaseHelper
							.getHelper(context).getLocalidadeDAO()
							.queryForId(local.getId());
					if (localidadeBD == null)
						DatabaseHelper.getHelper(context).getLocalidadeDAO()
								.create(local);
					else
						DatabaseHelper.getHelper(context).getLocalidadeDAO()
								.update(local);

				}
			}// Carrega dados localmente (modo offline).
			else {
				Collection<Persistencia> objs = DatabaseHelper
						.getHelper(context).getLocalidadeDAO()
						.queryForEq("id_unidade", idUnidade);
				for (Object object : objs) {
					Localidade local = (Localidade) object;
					localidades.add(local);
				}
			}
		} catch (SQLException e) {
			throw new DatabaseException(e.getMessage(), context);
		}
		return localidades;
	}

	public static ConstantesOperacoes getTipoAutenticacao() {
		return tipoAutenticacao;
	}

	public static void setTipoAutenticacao(ConstantesOperacoes tipoAutenticacao) {
		MainController.tipoAutenticacao = tipoAutenticacao;
	}

}
